/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").

Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "Precompiled.h"
#include "globaldata.h"
#include "Main.h"
#include "sys/sys_session.h"
#include "sys/sys_signin.h"
//#include "DoomLeaderboards.h"
#include "d3xp/Game_local.h"


#include <stdio.h>

#include "z_zone.h"

#include "m_random.h"
#include "m_swap.h"

#include "i_system.h"

#include "w_wad.h"

#include "g_game.h"

#include "r_local.h"
#include "s_sound.h"

#include "doomstat.h"

// Data.
#include "sounds.h"

// Needs access to LFB.
#include "v_video.h"

#include "wi_stuff.h"


//
// Data needed to add patches to full screen intermission pics.
// Patches are statistics messages, and animations.
// Loads of by-pixel layout and placement, offsets etc.
//


//
// Different vetween registered DOOM (1994) and
//  Ultimate DOOM - Final edition (retail, 1995?).
// This is supposedly ignored for commercial
//  release (aka DOOM II), which had 34 maps
//  in one episode. So there.


// in tics
//U #define PAUSELEN		(TICRATE*2)
//U #define SCORESTEP		100
//U #define ANIMPERIOD		32
// pixel distance from "(YOU)" to "PLAYER N"
//U #define STARDIST		10
//U #define WK 1


// GLOBAL LOCATIONS

// SINGPLE-PLAYER STUFF



// NET GAME STUFF



// DEATHMATCH STUFF










//
// Animation.
// There is another anim_t used in p_spec.
//


const point_t lnodes[NUMEPISODES][NUMMAPS] =
{
	// Episode 0 World Map
	{
		{ 185, 164 },	// location of level 0 (CJ)
		{ 148, 143 },	// location of level 1 (CJ)
		{ 69, 122 },	// location of level 2 (CJ)
		{ 209, 102 },	// location of level 3 (CJ)
		{ 116, 89 },	// location of level 4 (CJ)
		{ 166, 55 },	// location of level 5 (CJ)
		{ 71, 56 },	// location of level 6 (CJ)
		{ 135, 29 },	// location of level 7 (CJ)
		{ 71, 24 }	// location of level 8 (CJ)
	},

	// Episode 1 World Map should go here
	{
		{ 254, 25 },	// location of level 0 (CJ)
		{ 97, 50 },	// location of level 1 (CJ)
		{ 188, 64 },	// location of level 2 (CJ)
		{ 128, 78 },	// location of level 3 (CJ)
		{ 214, 92 },	// location of level 4 (CJ)
		{ 133, 130 },	// location of level 5 (CJ)
		{ 208, 136 },	// location of level 6 (CJ)
		{ 148, 140 },	// location of level 7 (CJ)
		{ 235, 158 }	// location of level 8 (CJ)
	},

	// Episode 2 World Map should go here
	{
		{ 156, 168 },	// location of level 0 (CJ)
		{ 48, 154 },	// location of level 1 (CJ)
		{ 174, 95 },	// location of level 2 (CJ)
		{ 265, 75 },	// location of level 3 (CJ)
		{ 130, 48 },	// location of level 4 (CJ)
		{ 279, 23 },	// location of level 5 (CJ)
		{ 198, 48 },	// location of level 6 (CJ)
		{ 140, 25 },	// location of level 7 (CJ)
		{ 281, 136 }	// location of level 8 (CJ)
	}

};


//
// Animation locations for episode 0 (1).
// Using patches saves a lot of space,
//  as they replace 320x200 full screen frames.
//
extern const anim_t temp_epsd0animinfo[10];
const anim_t temp_epsd0animinfo[10] =
{
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 224, 104 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 184, 160 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 112, 136 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 72, 112 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 88, 96 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 64, 48 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 192, 40 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 136, 16 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 80, 16 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 64, 24 } }
};

extern const anim_t temp_epsd1animinfo[9];
const anim_t temp_epsd1animinfo[9] =
{
	{ ANIM_LEVEL, TICRATE / 3, 1, { 128, 136 }, 1 },
	{ ANIM_LEVEL, TICRATE / 3, 1, { 128, 136 }, 2 },
	{ ANIM_LEVEL, TICRATE / 3, 1, { 128, 136 }, 3 },
	{ ANIM_LEVEL, TICRATE / 3, 1, { 128, 136 }, 4 },
	{ ANIM_LEVEL, TICRATE / 3, 1, { 128, 136 }, 5 },
	{ ANIM_LEVEL, TICRATE / 3, 1, { 128, 136 }, 6 },
	{ ANIM_LEVEL, TICRATE / 3, 1, { 128, 136 }, 7 },
	{ ANIM_LEVEL, TICRATE / 3, 3, { 192, 144 }, 8 },
	{ ANIM_LEVEL, TICRATE / 3, 1, { 128, 136 }, 8 }
};

extern const anim_t temp_epsd2animinfo[6];
const anim_t temp_epsd2animinfo[6] =
{
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 104, 168 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 40, 136 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 160, 96 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 104, 80 } },
	{ ANIM_ALWAYS, TICRATE / 3, 3, { 120, 32 } },
	{ ANIM_ALWAYS, TICRATE / 4, 3, { 40, 0 } }
};


//
// GENERAL DATA
//

//
// Locally used stuff.
//


// States for single-player


// in seconds
//#define SHOWLASTLOCDELAY	SHOWNEXTLOCDELAY


// used to accelerate or skip a stage

// ::g->wbs->pnum

// specifies current ::g->state

// contains information passed into intermission

const wbplayerstruct_t* plrs;  // ::g->wbs->plyr[]

// used for general timing

// used for timing of background animation

// signals to refresh everything for one frame


// # of commercial levels


//
//	GRAPHICS
//


//
// CODE
//



void localCalculateAchievements( bool epComplete )
{

	if( !common->IsMultiplayer() )
	{

		player_t*  player = &::g->players[::g->consoleplayer];

		// Calculate Any Achievements earned from stat cumulation.
		idAchievementManager::CheckDoomClassicsAchievements( player->killcount, player->itemcount, player->secretcount, ::g->gameskill, ::g->gamemission, ::g->gamemap, ::g->gameepisode, ::g->totalkills, ::g->totalitems, ::g->totalsecret );


	}
}

// slam background
// UNUSED static unsigned char *background=0;


void WI_slamBackground( void )
{
	memcpy( ::g->screens[0], ::g->screens[1], SCREENWIDTH * SCREENHEIGHT );
	V_MarkRect( 0, 0, SCREENWIDTH, SCREENHEIGHT );
}

// The ticker is used to detect keys
//  because of timing issues in netgames.
qboolean WI_Responder( event_t* ev )
{
	return false;
}

// Draws "<Levelname> Finished!"
void WI_drawLF( void )
{
	int y = WI_TITLEY;

	// draw <LevelName>
	V_DrawPatch( ( ORIGINAL_WIDTH - SHORT( ::g->lnames[::g->wbs->last]->width ) ) / 2,
				 y, FB, ::g->lnames[::g->wbs->last] );

	// draw "Finished!"
	y += ( 5 * SHORT( ::g->lnames[::g->wbs->last]->height ) ) / 4;

	V_DrawPatch( ( ORIGINAL_WIDTH - SHORT( ::g->finished->width ) ) / 2,
				 y, FB, ::g->finished );
}



// Draws "Entering <LevelName>"
void WI_drawEL( void )
{
	int y = WI_TITLEY;

	// draw "Entering"
	V_DrawPatch( ( ORIGINAL_WIDTH - SHORT( ::g->entering->width ) ) / 2,
				 y, FB, ::g->entering );

	// draw level
	y += ( 5 * SHORT( ::g->lnames[::g->wbs->next]->height ) ) / 4;

	V_DrawPatch( ( ORIGINAL_WIDTH - SHORT( ::g->lnames[::g->wbs->next]->width ) ) / 2,
				 y, FB, ::g->lnames[::g->wbs->next] );

}

void
WI_drawOnLnode
( int		n,
  patch_t*	c[] )
{

	int		i;
	int		left;
	int		top;
	int		right;
	int		bottom;
	qboolean	fits = false;

	i = 0;
	do
	{
		left = lnodes[::g->wbs->epsd][n].x - SHORT( c[i]->leftoffset );
		top = lnodes[::g->wbs->epsd][n].y - SHORT( c[i]->topoffset );
		right = left + SHORT( c[i]->width );
		bottom = top + SHORT( c[i]->height );

		if( left >= 0
				&& right < SCREENWIDTH
				&& top >= 0
				&& bottom < SCREENHEIGHT )
		{
			fits = true;
		}
		else
		{
			i++;
		}
	}
	while( !fits && i != 2 );

	if( fits && i < 2 )
	{
		V_DrawPatch( lnodes[::g->wbs->epsd][n].x, lnodes[::g->wbs->epsd][n].y,
					 FB, c[i] );
	}
	else
	{
		// DEBUG
		I_Printf( "Could not place patch on level %d", n + 1 );
	}
}



void WI_initAnimatedBack( void )
{
	int		i;
	anim_t*	a;

	if( ::g->gamemode == commercial )
	{
		return;
	}

	if( ::g->wbs->epsd > 2 )
	{
		return;
	}

	for( i = 0; i < ::g->NUMANIMS[::g->wbs->epsd]; i++ )
	{
		a = &::g->wi_stuff_anims[::g->wbs->epsd][i];

		// init variables
		a->ctr = -1;

		// specify the next time to draw it
		if( a->type == ANIM_ALWAYS )
		{
			a->nexttic = ::g->bcnt + 1 + ( M_Random() % a->period );
		}
		else if( a->type == ANIM_RANDOM )
		{
			a->nexttic = ::g->bcnt + 1 + a->data2 + ( M_Random() % a->data1 );
		}
		else if( a->type == ANIM_LEVEL )
		{
			a->nexttic = ::g->bcnt + 1;
		}
	}

}


void WI_updateAnimatedBack( void )
{
	int		i;
	anim_t*	a;

	if( ::g->gamemode == commercial )
	{
		return;
	}

	if( ::g->wbs->epsd > 2 )
	{
		return;
	}

	for( i = 0; i < ::g->NUMANIMS[::g->wbs->epsd]; i++ )
	{
		a = &::g->wi_stuff_anims[::g->wbs->epsd][i];

		if( ::g->bcnt == a->nexttic )
		{
			switch( a->type )
			{
				case ANIM_ALWAYS:
					if( ++a->ctr >= a->nanims )
					{
						a->ctr = 0;
					}
					a->nexttic = ::g->bcnt + a->period;
					break;

				case ANIM_RANDOM:
					a->ctr++;
					if( a->ctr == a->nanims )
					{
						a->ctr = -1;
						a->nexttic = ::g->bcnt + a->data2 + ( M_Random() % a->data1 );
					}
					else
					{
						a->nexttic = ::g->bcnt + a->period;
					}
					break;

				case ANIM_LEVEL:
					// gawd-awful hack for level anims
					if( !( ::g->state == StatCount && i == 7 )
							&& ::g->wbs->next == a->data1 )
					{
						a->ctr++;
						if( a->ctr == a->nanims )
						{
							a->ctr--;
						}
						a->nexttic = ::g->bcnt + a->period;
					}
					break;
			}
		}

	}

}

void WI_drawAnimatedBack( void )
{
	int			i;
	anim_t*		a;

	if( commercial )
	{
		return;
	}

	if( ::g->wbs->epsd > 2 )
	{
		return;
	}

	for( i = 0 ; i < ::g->NUMANIMS[::g->wbs->epsd] ; i++ )
	{
		a = &::g->wi_stuff_anims[::g->wbs->epsd][i];

		if( a->ctr >= 0 )
		{
			V_DrawPatch( a->loc.x, a->loc.y, FB, a->p[a->ctr] );
		}
	}

}

//
// Draws a number.
// If digits > 0, then use that many digits minimum,
//  otherwise only use as many as necessary.
// Returns new x position.
//

int
WI_drawNum
( int		x,
  int		y,
  int		n,
  int		digits )
{

	int		fontwidth = SHORT( ::g->num[0]->width );
	int		neg;
	int		temp;

	if( digits < 0 )
	{
		if( !n )
		{
			// make variable-length zeros 1 digit long
			digits = 1;
		}
		else
		{
			// figure out # of digits in #
			digits = 0;
			temp = n;

			while( temp )
			{
				temp /= 10;
				digits++;
			}
		}
	}

	neg = n < 0;
	if( neg )
	{
		n = -n;
	}

	// if non-number, do not draw it
	if( n == 1994 )
	{
		return 0;
	}

	// draw the new number
	while( digits-- )
	{
		x -= fontwidth;
		V_DrawPatch( x, y, FB, ::g->num[ n % 10 ] );
		n /= 10;
	}

	// draw a minus sign if necessary
	if( neg )
	{
		V_DrawPatch( x -= 8, y, FB, ::g->wiminus );
	}

	return x;

}

void
WI_drawPercent
( int		x,
  int		y,
  int		p )
{
	if( p < 0 )
	{
		return;
	}

	V_DrawPatch( x, y, FB, ::g->percent );
	WI_drawNum( x, y, p, -1 );
}



//
// Display level completion time and par,
//  or "sucks" message if overflow.
//
void
WI_drawTime
( int		x,
  int		y,
  int		t )
{

	int		div;
	int		n;

	if( t < 0 )
	{
		return;
	}

	if( t <= 61 * 59 )
	{
		div = 1;

		do
		{
			n = ( t / div ) % 60;
			x = WI_drawNum( x, y, n, 2 ) - SHORT( ::g->colon->width );
			div *= 60;

			// draw
			if( div == 60 || t / div )
			{
				V_DrawPatch( x, y, FB, ::g->colon );
			}

		}
		while( t / div );
	}
	else
	{
		// "sucks"
		V_DrawPatch( x - SHORT( ::g->sucks->width ), y, FB, ::g->sucks );
	}
}


void WI_End( void )
{
	void WI_unloadData( void );
	WI_unloadData();
}

void WI_initNoState( void )
{
	::g->state = NoState;
	::g->acceleratestage = 0;
	::g->cnt = 10;
}

void WI_updateNoState( void )
{

	WI_updateAnimatedBack();

	if( !--::g->cnt )
	{
		// Unload data
		WI_End();
		G_WorldDone();
	}

	DoomLib::ActivateGame();
}



void WI_initShowNextLoc( void )
{
	::g->state = ShowNextLoc;
	::g->acceleratestage = 0;
	::g->cnt = SHOWNEXTLOCDELAY * TICRATE;

	WI_initAnimatedBack();

	DoomLib::ActivateGame();
}

void WI_updateShowNextLoc( void )
{
	WI_updateAnimatedBack();

	if( !--::g->cnt || ::g->acceleratestage )
	{
		WI_initNoState();
		DoomLib::ShowXToContinue( false );
	}
	else
	{
		::g->snl_pointeron = ( ::g->cnt & 31 ) < 20;
	}
}

void WI_drawShowNextLoc( void )
{

	int		i;
	int		last;

	WI_slamBackground();

	// draw animated background
	WI_drawAnimatedBack();

	if( ::g->gamemode != commercial )
	{
		if( ::g->wbs->epsd > 2 )
		{
			WI_drawEL();
			return;
		}

		last = ( ::g->wbs->last == 8 ) ? ::g->wbs->next - 1 : ::g->wbs->last;

		// don't draw any splats for extra secret levels
		if( last == 9 )
		{
			for( i = 0 ; i < MAXPLAYERS ; i++ )
			{
				::g->players[i].didsecret = false;
			}
			::g->wbs->didsecret = false;
			last = -1;
		}

		// draw a splat on taken cities.
		for( i = 0 ; i <= last ; i++ )
		{
			WI_drawOnLnode( i, &::g->splat );
		}

		// splat the secret level?
		if( ::g->wbs->didsecret )
		{
			WI_drawOnLnode( 8, &::g->splat );
		}

		// draw flashing ptr
		if( ::g->snl_pointeron )
		{
			WI_drawOnLnode( ::g->wbs->next, ::g->yah );
		}
	}

	// draws which level you are entering..
	if( ( ::g->gamemode != commercial )
			|| ::g->wbs->next != 30 )
	{
		WI_drawEL();
	}

}

void WI_drawNoState( void )
{
	::g->snl_pointeron = true;
	WI_drawShowNextLoc();
}

int WI_fragSum( int playernum )
{
	int		i;
	int		frags = 0;

	for( i = 0 ; i < MAXPLAYERS ; i++ )
	{
		if( /*::g->playeringame[i] &&*/ i != playernum )
		{
			frags += plrs[playernum].frags[i];
		}
	}


	// JDC hack - negative frags.
	frags -= plrs[playernum].frags[playernum];
	// UNUSED if (frags < 0)
	// 	frags = 0;

	return frags;
}

int WI_fragOnlySum( int playernum )
{
	int		i;
	int		frags = 0;

	for( i = 0 ; i < MAXPLAYERS ; i++ )
	{
		if( /*::g->playeringame[i] &&*/ i != playernum )
		{
			frags += plrs[playernum].frags[i];
		}
	}

	return frags;
}

int WI_deathSum( int playernum )
{
	int		i;
	int		deaths = 0;

	for( i = 0 ; i < MAXPLAYERS ; i++ )
	{
		if( 1 /*::g->playeringame[i]*/ )
		{
			deaths += plrs[i].frags[playernum];
		}
	}

	return deaths;
}






void WI_initDeathmatchStats( void )
{

	int		i;
	int		j;

	::g->state = StatCount;
	::g->acceleratestage = 0;
	::g->dm_state = 1;

	::g->cnt_pause = TICRATE;

	for( i = 0 ; i < MAXPLAYERS ; i++ )
	{
		if( ::g->playeringame[i] )
		{
			for( j = 0 ; j < MAXPLAYERS ; j++ )
				if( ::g->playeringame[j] )
				{
					::g->dm_frags[i][j] = 0;
				}

			::g->dm_totals[i] = 0;
		}
	}

	WI_initAnimatedBack();

	if( common->IsMultiplayer() )
	{
		localCalculateAchievements( false );

		/* JAF PS3
		gameLocal->liveSession.GetDMSession().SetEndOfMatchStats();
		gameLocal->liveSession.GetDMSession().WriteTrueskill();

		// Write stats
		if ( gameLocal->liveSession.IsHost( ::g->consoleplayer ) ) {
			gameLocal->liveSession.GetDMSession().BeginEndLevel();
		}
		*/
	}

	DoomLib::ShowXToContinue( true );
}



void WI_updateDeathmatchStats( void )
{

	int		i;
	int		j;

	qboolean	stillticking;

	WI_updateAnimatedBack();

	if( ::g->acceleratestage && ::g->dm_state != 4 )
	{
		::g->acceleratestage = 0;

		for( i = 0 ; i < MAXPLAYERS ; i++ )
		{
			if( ::g->playeringame[i] )
			{
				for( j = 0 ; j < MAXPLAYERS ; j++ )
					if( ::g->playeringame[j] )
					{
						::g->dm_frags[i][j] = plrs[i].frags[j];
					}

				::g->dm_totals[i] = WI_fragSum( i );
			}
		}


		S_StartSound( 0, sfx_barexp );
		::g->dm_state = 4;
	}


	if( ::g->dm_state == 2 )
	{
		if( !( ::g->bcnt & 3 ) )
		{
			S_StartSound( 0, sfx_pistol );
		}

		stillticking = false;

		for( i = 0 ; i < MAXPLAYERS ; i++ )
		{
			if( ::g->playeringame[i] )
			{
				for( j = 0 ; j < MAXPLAYERS ; j++ )
				{
					if( ::g->playeringame[j]
							&& ::g->dm_frags[i][j] != plrs[i].frags[j] )
					{
						if( plrs[i].frags[j] < 0 )
						{
							::g->dm_frags[i][j]--;
						}
						else
						{
							::g->dm_frags[i][j]++;
						}

						if( ::g->dm_frags[i][j] > 99 )
						{
							::g->dm_frags[i][j] = 99;
						}

						if( ::g->dm_frags[i][j] < -99 )
						{
							::g->dm_frags[i][j] = -99;
						}

						stillticking = true;
					}
				}
				::g->dm_totals[i] = WI_fragSum( i );

				if( ::g->dm_totals[i] > 99 )
				{
					::g->dm_totals[i] = 99;
				}

				if( ::g->dm_totals[i] < -99 )
				{
					::g->dm_totals[i] = -99;
				}
			}

		}
		if( !stillticking )
		{
			S_StartSound( 0, sfx_barexp );
			::g->dm_state++;
		}

	}
	else if( ::g->dm_state == 4 )
	{
		if( ::g->acceleratestage )
		{
			if( !::g->demoplayback && ( ::g->usergame || ::g->netgame ) )
			{
				// This sound plays repeatedly after a player continues at the end of a deathmatch,
				// and sounds bad. Quick fix is to just not play it.
				//S_StartSound(0, sfx_slop);

				DoomLib::HandleEndMatch();
			}
		}
	}
	else if( ::g->dm_state & 1 )
	{
		if( !--::g->cnt_pause )
		{
			::g->dm_state++;
			::g->cnt_pause = TICRATE;
		}
	}
}



void WI_drawDeathmatchStats( void )
{

	int		i;
	int		j;
	int		x;
	int		y;
	int		w;

	int		lh;	// line height

	lh = WI_SPACINGY;

	WI_slamBackground();

	// draw animated background
	WI_drawAnimatedBack();
	WI_drawLF();

	// draw stat titles (top line)
	V_DrawPatch( DM_TOTALSX - SHORT( ::g->total->width ) / 2,
				 DM_MATRIXY - WI_SPACINGY + 10,
				 FB,
				 ::g->total );

	V_DrawPatch( DM_KILLERSX, DM_KILLERSY, FB, ::g->killers );
	V_DrawPatch( DM_VICTIMSX, DM_VICTIMSY, FB, ::g->victims );

	// draw P?
	x = DM_MATRIXX + DM_SPACINGX;
	y = DM_MATRIXY;

	for( i = 0 ; i < MAXPLAYERS ; i++ )
	{
		if( ::g->playeringame[i] )
		{
			V_DrawPatch( x - SHORT( ::g->wistuff_p[i]->width ) / 2,
						 DM_MATRIXY - WI_SPACINGY,
						 FB,
						 ::g->wistuff_p[i] );

			V_DrawPatch( DM_MATRIXX - SHORT( ::g->wistuff_p[i]->width ) / 2,
						 y,
						 FB,
						 ::g->wistuff_p[i] );

			// No splitscreen on PC currently
			if( i == ::g->me /* && !gameLocal->IsSplitscreen() */ )
			{
				V_DrawPatch( x - SHORT( ::g->wistuff_p[i]->width ) / 2,
							 DM_MATRIXY - WI_SPACINGY,
							 FB,
							 ::g->bstar );

				V_DrawPatch( DM_MATRIXX - SHORT( ::g->wistuff_p[i]->width ) / 2,
							 y,
							 FB,
							 ::g->star );
			}
		}
		else
		{
			//V_DrawPatch(x-SHORT(::g->wistuff_bp[i]->width)/2,
			//  DM_MATRIXY - WI_SPACINGY, FB, ::g->wistuff_bp[i]);
			//V_DrawPatch(DM_MATRIXX-SHORT(::g->wistuff_bp[i]->width)/2,
			// y, FB, ::g->wistuff_bp[i]);
		}
		x += DM_SPACINGX;
		y += WI_SPACINGY;
	}

	// draw stats
	y = DM_MATRIXY + 10;
	w = SHORT( ::g->num[0]->width );

	for( i = 0 ; i < MAXPLAYERS ; i++ )
	{
		x = DM_MATRIXX + DM_SPACINGX;

		if( ::g->playeringame[i] )
		{
			for( j = 0 ; j < MAXPLAYERS ; j++ )
			{
				if( ::g->playeringame[j] )
				{
					WI_drawNum( x + w, y, ::g->dm_frags[i][j], 2 );
				}

				x += DM_SPACINGX;
			}
			WI_drawNum( DM_TOTALSX + w, y, ::g->dm_totals[i], 2 );
		}
		y += WI_SPACINGY;
	}
}


void WI_initNetgameStats( void )
{

	int i;

	::g->state = StatCount;
	::g->acceleratestage = 0;
	::g->ng_state = 1;

	::g->cnt_pause = TICRATE;

	for( i = 0 ; i < MAXPLAYERS ; i++ )
	{
		if( !::g->playeringame[i] )
		{
			continue;
		}

		::g->cnt_kills[i] = ::g->cnt_items[i] = ::g->cnt_secret[i] = ::g->cnt_frags[i] = 0;

		::g->dofrags += WI_fragSum( i );
	}

	::g->dofrags = !!::g->dofrags;

	WI_initAnimatedBack();

	// JAF PS3
	/*
	if ( gameLocal->IsMultiplayer() ) {
		if(gameLocal->IsFullVersion() && gameLocal->liveSession.IsHost( ::g->consoleplayer )) {
			bool endOfMission = false;

			if ( ::g->gamemission == 0 && ::g->gamemap == 30 ) {
				endOfMission = true;
			}
			else if ( ::g->gamemission > 0 && ::g->gamemap == 8 ) {
				endOfMission = true;
			}

			gameLocal->liveSession.GetCoopSession().BeginEndLevel( endOfMission );
		}
	}
	*/

	DoomLib::ShowXToContinue( true );

}



void WI_updateNetgameStats( void )
{

	int		i;
	int		fsum;

	qboolean	stillticking;

	WI_updateAnimatedBack();

	if( ::g->acceleratestage && ::g->ng_state != 10 )
	{
		::g->acceleratestage = 0;

		for( i = 0 ; i < MAXPLAYERS ; i++ )
		{
			if( !::g->playeringame[i] )
			{
				continue;
			}

			::g->cnt_kills[i] = ( plrs[i].skills * 100 ) / ::g->wbs->maxkills;
			::g->cnt_items[i] = ( plrs[i].sitems * 100 ) / ::g->wbs->maxitems;
			::g->cnt_secret[i] = ( plrs[i].ssecret * 100 ) / ::g->wbs->maxsecret;

			if( ::g->dofrags )
			{
				::g->cnt_frags[i] = WI_fragSum( i );
			}
		}
		S_StartSound( 0, sfx_barexp );
		::g->ng_state = 10;
	}

	if( ::g->ng_state == 2 )
	{
		if( !( ::g->bcnt & 3 ) )
		{
			S_StartSound( 0, sfx_pistol );
		}

		stillticking = false;

		for( i = 0 ; i < MAXPLAYERS ; i++ )
		{
			if( !::g->playeringame[i] )
			{
				continue;
			}

			::g->cnt_kills[i] += 2;

			if( ::g->cnt_kills[i] >= ( plrs[i].skills * 100 ) / ::g->wbs->maxkills )
			{
				::g->cnt_kills[i] = ( plrs[i].skills * 100 ) / ::g->wbs->maxkills;
			}
			else
			{
				stillticking = true;
			}
		}

		if( !stillticking )
		{
			S_StartSound( 0, sfx_barexp );
			::g->ng_state++;
		}
	}
	else if( ::g->ng_state == 4 )
	{
		if( !( ::g->bcnt & 3 ) )
		{
			S_StartSound( 0, sfx_pistol );
		}

		stillticking = false;

		for( i = 0 ; i < MAXPLAYERS ; i++ )
		{
			if( !::g->playeringame[i] )
			{
				continue;
			}

			::g->cnt_items[i] += 2;
			if( ::g->cnt_items[i] >= ( plrs[i].sitems * 100 ) / ::g->wbs->maxitems )
			{
				::g->cnt_items[i] = ( plrs[i].sitems * 100 ) / ::g->wbs->maxitems;
			}
			else
			{
				stillticking = true;
			}
		}
		if( !stillticking )
		{
			S_StartSound( 0, sfx_barexp );
			::g->ng_state++;
		}
	}
	else if( ::g->ng_state == 6 )
	{
		if( !( ::g->bcnt & 3 ) )
		{
			S_StartSound( 0, sfx_pistol );
		}

		stillticking = false;

		for( i = 0 ; i < MAXPLAYERS ; i++ )
		{
			if( !::g->playeringame[i] )
			{
				continue;
			}

			::g->cnt_secret[i] += 2;

			if( ::g->cnt_secret[i] >= ( plrs[i].ssecret * 100 ) / ::g->wbs->maxsecret )
			{
				::g->cnt_secret[i] = ( plrs[i].ssecret * 100 ) / ::g->wbs->maxsecret;
			}
			else
			{
				stillticking = true;
			}
		}

		if( !stillticking )
		{
			S_StartSound( 0, sfx_barexp );
			::g->ng_state += 1 + 2 * !::g->dofrags;
		}
	}
	else if( ::g->ng_state == 8 )
	{
		if( !( ::g->bcnt & 3 ) )
		{
			S_StartSound( 0, sfx_pistol );
		}

		stillticking = false;

		for( i = 0 ; i < MAXPLAYERS ; i++ )
		{
			if( !::g->playeringame[i] )
			{
				continue;
			}

			::g->cnt_frags[i] += 1;

			if( ::g->cnt_frags[i] >= ( fsum = WI_fragSum( i ) ) )
			{
				::g->cnt_frags[i] = fsum;
			}
			else
			{
				stillticking = true;
			}
		}

		if( !stillticking )
		{
			S_StartSound( 0, sfx_pldeth );
			::g->ng_state++;
		}
	}
	else if( ::g->ng_state == 10 )
	{
		if( ::g->acceleratestage )
		{
			if( !::g->demoplayback && ( ::g->usergame || ::g->netgame ) )
			{
				S_StartSound( 0, sfx_sgcock );

				// need to do this again if they buy it
				localCalculateAchievements( false );
				if( ::g->gamemode == commercial )
				{
					WI_initNoState();
					DoomLib::ShowXToContinue( false );
				}
				else
				{
					WI_initShowNextLoc();
				}
			}
		}
	}
	else if( ::g->ng_state & 1 )
	{
		if( !--::g->cnt_pause )
		{
			::g->ng_state++;
			::g->cnt_pause = TICRATE;
		}
	}
}



void WI_drawNetgameStats( void )
{
	int		i;
	int		x;
	int		y;
	int		pwidth = SHORT( ::g->percent->width );

	WI_slamBackground();

	// draw animated background
	WI_drawAnimatedBack();

	WI_drawLF();

	// draw stat titles (top line)
	V_DrawPatch( NG_STATSX + NG_SPACINGX - SHORT( ::g->kills->width ),
				 NG_STATSY, FB, ::g->kills );

	V_DrawPatch( NG_STATSX + 2 * NG_SPACINGX - SHORT( ::g->items->width ),
				 NG_STATSY, FB, ::g->items );

	V_DrawPatch( NG_STATSX + 3 * NG_SPACINGX - SHORT( ::g->secret->width ),
				 NG_STATSY, FB, ::g->secret );

	if( ::g->dofrags )
		V_DrawPatch( NG_STATSX + 4 * NG_SPACINGX - SHORT( ::g->wistuff_frags->width ),
					 NG_STATSY, FB, ::g->wistuff_frags );

	// draw stats
	y = NG_STATSY + SHORT( ::g->kills->height );

	for( i = 0 ; i < MAXPLAYERS ; i++ )
	{
		if( !::g->playeringame[i] )
		{
			continue;
		}

		x = NG_STATSX;
		V_DrawPatch( x - SHORT( ::g->wistuff_p[i]->width ), y, FB, ::g->wistuff_p[i] );

		// No splitscreen on PC
		if( i == ::g->me /* && !gameLocal->IsSplitscreen() */ )
		{
			V_DrawPatch( x - SHORT( ::g->wistuff_p[i]->width ), y, FB, ::g->star );
		}

		x += NG_SPACINGX;
		WI_drawPercent( x - pwidth, y + 10, ::g->cnt_kills[i] );
		x += NG_SPACINGX;
		WI_drawPercent( x - pwidth, y + 10, ::g->cnt_items[i] );
		x += NG_SPACINGX;
		WI_drawPercent( x - pwidth, y + 10, ::g->cnt_secret[i] );
		x += NG_SPACINGX;

		if( ::g->dofrags )
		{
			WI_drawNum( x, y + 10, ::g->cnt_frags[i], -1 );
		}

		y += WI_SPACINGY;
	}

}


void WI_initStats( void )
{
	::g->state = StatCount;
	::g->acceleratestage = 0;
	::g->sp_state = 1;
	::g->cnt_kills[0] = ::g->cnt_items[0] = ::g->cnt_secret[0] = -1;
	::g->cnt_time = ::g->cnt_par = -1;
	::g->cnt_pause = TICRATE;

	WI_initAnimatedBack();

	DoomLib::ShowXToContinue( true );
}

void WI_updateStats( void )
{

	WI_updateAnimatedBack();

	if( ::g->acceleratestage && ::g->sp_state != 10 )
	{
		::g->acceleratestage = 0;
		::g->cnt_kills[0] = ( plrs[::g->me].skills * 100 ) / ::g->wbs->maxkills;
		::g->cnt_items[0] = ( plrs[::g->me].sitems * 100 ) / ::g->wbs->maxitems;
		::g->cnt_secret[0] = ( plrs[::g->me].ssecret * 100 ) / ::g->wbs->maxsecret;
		::g->cnt_time = plrs[::g->me].stime / TICRATE;
		::g->cnt_par = ::g->wbs->partime / TICRATE;
		S_StartSound( 0, sfx_barexp );
		::g->sp_state = 10;
	}

	if( ::g->sp_state == 2 )
	{
		::g->cnt_kills[0] += 2;

		if( !( ::g->bcnt & 3 ) )
		{
			S_StartSound( 0, sfx_pistol );
		}

		if( ::g->cnt_kills[0] >= ( plrs[::g->me].skills * 100 ) / ::g->wbs->maxkills )
		{
			::g->cnt_kills[0] = ( plrs[::g->me].skills * 100 ) / ::g->wbs->maxkills;
			S_StartSound( 0, sfx_barexp );
			::g->sp_state++;
		}
	}
	else if( ::g->sp_state == 4 )
	{
		::g->cnt_items[0] += 2;

		if( !( ::g->bcnt & 3 ) )
		{
			S_StartSound( 0, sfx_pistol );
		}

		if( ::g->cnt_items[0] >= ( plrs[::g->me].sitems * 100 ) / ::g->wbs->maxitems )
		{
			::g->cnt_items[0] = ( plrs[::g->me].sitems * 100 ) / ::g->wbs->maxitems;
			S_StartSound( 0, sfx_barexp );
			::g->sp_state++;
		}
	}
	else if( ::g->sp_state == 6 )
	{
		::g->cnt_secret[0] += 2;

		if( !( ::g->bcnt & 3 ) )
		{
			S_StartSound( 0, sfx_pistol );
		}

		if( ::g->cnt_secret[0] >= ( plrs[::g->me].ssecret * 100 ) / ::g->wbs->maxsecret )
		{
			::g->cnt_secret[0] = ( plrs[::g->me].ssecret * 100 ) / ::g->wbs->maxsecret;
			S_StartSound( 0, sfx_barexp );
			::g->sp_state++;
		}
	}

	else if( ::g->sp_state == 8 )
	{
		if( !( ::g->bcnt & 3 ) )
		{
			S_StartSound( 0, sfx_pistol );
		}

		::g->cnt_time += 3;

		if( ::g->cnt_time >= plrs[::g->me].stime / TICRATE )
		{
			::g->cnt_time = plrs[::g->me].stime / TICRATE;
		}

		::g->cnt_par += 3;

		if( ::g->cnt_par >= ::g->wbs->partime / TICRATE )
		{
			::g->cnt_par = ::g->wbs->partime / TICRATE;

			if( ::g->cnt_time >= plrs[::g->me].stime / TICRATE )
			{
				S_StartSound( 0, sfx_barexp );
				::g->sp_state++;
			}
		}
	}
	else if( ::g->sp_state == 10 )
	{
		if( ::g->acceleratestage )
		{
			if( !::g->demoplayback && ( ::g->usergame || ::g->netgame ) )
			{

				S_StartSound( 0, sfx_sgcock );

				// need to do this again if they buy it
				localCalculateAchievements( false );

				if( ::g->gamemode == commercial )
				{
					WI_initNoState();
				}
				else
				{
					WI_initShowNextLoc();
				}
			}
		}
	}
	else if( ::g->sp_state & 1 )
	{
		if( !--::g->cnt_pause )
		{
			::g->sp_state++;
			::g->cnt_pause = TICRATE;
		}
	}

}

void WI_drawStats( void )
{
	// line height
	int lh;

	lh = ( 3 * SHORT( ::g->num[0]->height ) ) / 2;

	WI_slamBackground();

	// draw animated background
	WI_drawAnimatedBack();

	WI_drawLF();

	V_DrawPatch( SP_STATSX, SP_STATSY, FB, ::g->kills );
	WI_drawPercent( ORIGINAL_WIDTH - SP_STATSX, SP_STATSY, ::g->cnt_kills[0] );

	V_DrawPatch( SP_STATSX, SP_STATSY + lh, FB, ::g->items );
	WI_drawPercent( ORIGINAL_WIDTH - SP_STATSX, SP_STATSY + lh, ::g->cnt_items[0] );

	V_DrawPatch( SP_STATSX, SP_STATSY + 2 * lh, FB, ::g->sp_secret );
	WI_drawPercent( ORIGINAL_WIDTH - SP_STATSX, SP_STATSY + 2 * lh, ::g->cnt_secret[0] );

	V_DrawPatch( SP_TIMEX, SP_TIMEY, FB, ::g->time );
	WI_drawTime( ORIGINAL_WIDTH / 2 - SP_TIMEX, SP_TIMEY, ::g->cnt_time );

	// DHM - Nerve :: Added episode 4 par times
	//if (::g->wbs->epsd < 3)
	//{
	V_DrawPatch( ORIGINAL_WIDTH / 2 + SP_TIMEX, SP_TIMEY, FB, ::g->par );
	WI_drawTime( ORIGINAL_WIDTH - SP_TIMEX, SP_TIMEY, ::g->cnt_par );
	//}

}

void WI_checkForAccelerate( void )
{
	int   i;
	player_t*  player;

	// check for button presses to skip delays
	for( i = 0, player = ::g->players ; i < MAXPLAYERS ; i++, player++ )
	{
		if( ::g->playeringame[i] )
		{
			if( player->cmd.buttons & BT_ATTACK )
			{
				if( !player->attackdown )
				{
					::g->acceleratestage = 1;
				}
				player->attackdown = true;
			}
			else
			{
				player->attackdown = false;
			}
			if( player->cmd.buttons & BT_USE )
			{
				if( !player->usedown )
				{
					::g->acceleratestage = 1;
				}
				player->usedown = true;

			}
			else
			{
				player->usedown = false;
			}
		}
	}
}



// Updates stuff each tick
void WI_Ticker( void )
{
	// counter for general background animation
	::g->bcnt++;

	if( ::g->bcnt == 1 )
	{
		// intermission music
		if( ::g->gamemode == commercial )
		{
			S_ChangeMusic( mus_dm2int, true );
		}
		else
		{
			S_ChangeMusic( mus_inter, true );
		}
	}

	WI_checkForAccelerate();

	switch( ::g->state )
	{
		case StatCount:
			if( ::g->deathmatch )
			{
				WI_updateDeathmatchStats();
			}
			else if( ::g->netgame )
			{
				WI_updateNetgameStats();
			}
			else
			{
				WI_updateStats();
			}
			break;

		case ShowNextLoc:
			WI_updateShowNextLoc();
			break;

		case NoState:
			WI_updateNoState();
			break;
	}

}

void WI_loadData( void )
{
	int		i;
	int		j;
	char	name[9];
	anim_t*	a;

	if( ::g->gamemode == commercial )
	{
		strcpy( name, "INTERPIC" );
	}
	// DHM - Nerve :: Use our background image
	//strcpy(name, "DMENUPIC");
	else
	{
		idStr::snPrintf( name, sizeof( name ), "WIMAP%d", ::g->wbs->epsd );
	}

	if( ::g->gamemode == retail )
	{
		if( ::g->wbs->epsd == 3 )
		{
			strcpy( name, "INTERPIC" );
		}
	}

	// background
	::g->bg = ( patch_t* )W_CacheLumpName( name, PU_LEVEL_SHARED );

	V_DrawPatch( 0, 0, 1, ::g->bg );


	// UNUSED unsigned char *pic = ::g->screens[1];
	// if (::g->gamemode == commercial)
	// {
	// darken the background image
	// while (pic != ::g->screens[1] + SCREENHEIGHT*SCREENWIDTH)
	// {
	//   *pic = ::g->colormaps[256*25 + *pic];
	//   pic++;
	// }
	//}

	if( ::g->gamemode == commercial )
	{
		::g->NUMCMAPS = 32;
		::g->lnames = ( patch_t** ) DoomLib::Z_Malloc( sizeof( patch_t* ) * ::g->NUMCMAPS, PU_LEVEL_SHARED, 0 );
		for( i = 0 ; i < ::g->NUMCMAPS ; i++ )
		{
			idStr::snPrintf( name, sizeof( name ), "CWILV%2.2d", i );
			::g->lnames[i] = ( patch_t* )W_CacheLumpName( name, PU_LEVEL_SHARED );
		}
	}
	else
	{
		::g->lnames = ( patch_t** ) DoomLib::Z_Malloc( sizeof( patch_t* ) * ( NUMMAPS ), PU_LEVEL_SHARED, 0 );
		for( i = 0 ; i < NUMMAPS ; i++ )
		{
			idStr::snPrintf( name, sizeof( name ), "WILV%d%d", ::g->wbs->epsd, i );
			::g->lnames[i] = ( patch_t* )W_CacheLumpName( name, PU_LEVEL_SHARED );
		}

		// you are here
		::g->yah[0] = ( patch_t* )W_CacheLumpName( "WIURH0", PU_LEVEL_SHARED );

		// you are here (alt.)
		::g->yah[1] = ( patch_t* )W_CacheLumpName( "WIURH1", PU_LEVEL_SHARED );

		// splat
		::g->splat = ( patch_t* )W_CacheLumpName( "WISPLAT", PU_LEVEL_SHARED );

		if( ::g->wbs->epsd < 3 )
		{
			for( j = 0; j < ::g->NUMANIMS[::g->wbs->epsd]; j++ )
			{
				a = &::g->wi_stuff_anims[::g->wbs->epsd][j];
				for( i = 0; i < a->nanims; i++ )
				{
					// MONDO HACK!
					if( ::g->wbs->epsd != 1 || j != 8 )
					{
						// animations
						idStr::snPrintf( name, sizeof( name ), "WIA%d%.2d%.2d", ::g->wbs->epsd, j, i );
						a->p[i] = ( patch_t* )W_CacheLumpName( name, PU_LEVEL_SHARED );
					}
					else
					{
						// HACK ALERT!
						a->p[i] = ::g->wi_stuff_anims[1][4].p[i];
					}
				}
			}
		}
	}

	// More hacks on minus sign.
	::g->wiminus = ( patch_t* )W_CacheLumpName( "WIMINUS", PU_LEVEL_SHARED );

	for( i = 0; i < 10; i++ )
	{
		// numbers 0-9
		idStr::snPrintf( name, sizeof( name ), "WINUM%d", i );
		::g->num[i] = ( patch_t* )W_CacheLumpName( name, PU_LEVEL_SHARED );
	}

	// percent sign
	::g->percent = ( patch_t* )W_CacheLumpName( "WIPCNT", PU_LEVEL_SHARED );

	// "finished"
	::g->finished = ( patch_t* )W_CacheLumpName( "WIF", PU_LEVEL_SHARED );

	// "entering"
	::g->entering = ( patch_t* )W_CacheLumpName( "WIENTER", PU_LEVEL_SHARED );

	// "kills"
	::g->kills = ( patch_t* )W_CacheLumpName( "WIOSTK", PU_LEVEL_SHARED );

	// "scrt"
	::g->secret = ( patch_t* )W_CacheLumpName( "WIOSTS", PU_LEVEL_SHARED );

	// "secret"
	::g->sp_secret = ( patch_t* )W_CacheLumpName( "WISCRT2", PU_LEVEL_SHARED );

	::g->items = ( patch_t* )W_CacheLumpName( "WIOSTI", PU_LEVEL_SHARED );

	// "frgs"
	::g->wistuff_frags = ( patch_t* )W_CacheLumpName( "WIFRGS", PU_LEVEL_SHARED );

	// ":"
	::g->colon = ( patch_t* )W_CacheLumpName( "WICOLON", PU_LEVEL_SHARED );

	// "time"
	::g->time = ( patch_t* )W_CacheLumpName( "WITIME", PU_LEVEL_SHARED );

	// "sucks"
	::g->sucks = ( patch_t* )W_CacheLumpName( "WISUCKS", PU_LEVEL_SHARED );

	// "par"
	::g->par = ( patch_t* )W_CacheLumpName( "WIPAR", PU_LEVEL_SHARED );

	// "killers" (vertical)
	::g->killers = ( patch_t* )W_CacheLumpName( "WIKILRS", PU_LEVEL_SHARED );

	// "victims" (horiz)
	::g->victims = ( patch_t* )W_CacheLumpName( "WIVCTMS", PU_LEVEL_SHARED );

	// "total"
	::g->total = ( patch_t* )W_CacheLumpName( "WIMSTT", PU_LEVEL_SHARED );

	// your face
	::g->star = ( patch_t* )W_CacheLumpName( "STFST01", PU_STATIC_SHARED ); // ALAN: this is statically in the game...

	// dead face
	::g->bstar = ( patch_t* )W_CacheLumpName( "STFDEAD0", PU_STATIC_SHARED );

	for( i = 0 ; i < MAXPLAYERS ; i++ )
	{
		// "1,2,3,4"
		idStr::snPrintf( name, sizeof( name ), "STPB%d", i );
		::g->wistuff_p[i] = ( patch_t* )W_CacheLumpName( name, PU_LEVEL_SHARED );

		// "1,2,3,4"
		idStr::snPrintf( name, sizeof( name ), "WIBP%d", i + 1 );
		::g->wistuff_bp[i] = ( patch_t* )W_CacheLumpName( name, PU_LEVEL_SHARED );
	}

}

void WI_unloadData( void )
{
	Z_FreeTags( PU_LEVEL_SHARED, PU_LEVEL_SHARED );
	// HACK ALERT - reset these to help stability? they are used for consistency checking
	for( int i = 0 ; i < MAXPLAYERS ; i++ )
	{
		if( ::g->playeringame[i] )
		{
			::g->players[i].mo = NULL;
		}
	}
	::g->bg = NULL;
}

void WI_Drawer( void )
{
	switch( ::g->state )
	{
		case StatCount:
			if( ::g->deathmatch )
			{
				WI_drawDeathmatchStats();
			}
			else if( ::g->netgame )
			{
				WI_drawNetgameStats();
			}
			else
			{
				WI_drawStats();
			}
			break;

		case ShowNextLoc:
			WI_drawShowNextLoc();
			break;

		case NoState:
			WI_drawNoState();
			break;
	}
}


void WI_initVariables( wbstartstruct_t* wbstartstruct )
{

	::g->wbs = wbstartstruct;

#ifdef RANGECHECKING
	if( ::g->gamemode != commercial )
	{
		if( ::g->gamemode == retail )
		{
			RNGCHECK( ::g->wbs->epsd, 0, 3 );
		}
		else
		{
			RNGCHECK( ::g->wbs->epsd, 0, 2 );
		}
	}
	else
	{
		RNGCHECK( ::g->wbs->last, 0, 8 );
		RNGCHECK( ::g->wbs->next, 0, 8 );
	}
	RNGCHECK( ::g->wbs->pnum, 0, MAXPLAYERS );
	RNGCHECK( ::g->wbs->pnum, 0, MAXPLAYERS );
#endif

	::g->acceleratestage = 0;
	::g->cnt = ::g->bcnt = 0;
	::g->firstrefresh = 1;
	::g->me = ::g->wbs->pnum;
	plrs = ::g->wbs->plyr;

	if( !::g->wbs->maxkills )
	{
		::g->wbs->maxkills = 1;
	}

	if( !::g->wbs->maxitems )
	{
		::g->wbs->maxitems = 1;
	}

	if( !::g->wbs->maxsecret )
	{
		::g->wbs->maxsecret = 1;
	}

	if( ::g->gamemode != retail )
		if( ::g->wbs->epsd > 2 )
		{
			::g->wbs->epsd -= 3;
		}
}

void WI_Start( wbstartstruct_t* wbstartstruct )
{

	WI_initVariables( wbstartstruct );
	WI_loadData();

	if( ::g->deathmatch )
	{
		WI_initDeathmatchStats();
	}
	else if( ::g->netgame )
	{
		WI_initNetgameStats();
	}
	else
	{
		WI_initStats();
	}
}
